package com.chenchao.javageneric;


import com.chenchao.javaoop.Student;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @encoding : UTF-8
 * @Time : 2020/11/13 9:33
 * @Author : Chen Chao
 * @File : javaSE.com.chenchao.javageneric.Test1.java
 * @Software : IntelliJ IDEA
 * @since : 1.8
 */
public class Test1 {
    public static void main(String[] args) {

        //test();
        //trslate();
        //trslate2();
        nested();
    }

    public static void test(){
        ArrayList<java.lang.String> strings = new ArrayList<>();
        //前后类型保持一致（也不能用父类）,后面可以不写（语法糖）
        strings.add("gg1");
        strings.add("gg2fddsfs");
        strings.add("ggdsf3");
        strings.add("ggdsf4dfs");
        for (java.lang.String string : strings) {
            System.out.println(string.length());

        }
        //?泛型通配符，只做接收使用
        ArrayList<?> objects = new ArrayList<>();
        //泛型擦除，把已知泛型赋给未知泛型
        ArrayList<String> strings2 = new ArrayList<>();
        List list2=null;
        list2=strings2;
        //String被擦除了
        list2.add(1);

    }
    public <T> void test2(){

    }
     static <T> T test3(T name){
        return name;
    }
    /**
     * 泛型的上下限
     * 上限，用来限定必须是指定类型的子类
     * 下限，用来限定必须是指定类型的父类
     */
    static void test4(List<?extends Number> list){

    }

    static void test5(List<? super Number> list){

    }
    /**
     * 数组转list
     * 转成的list仍然不可变长
     */
    public static void trslate(){
        int[] arr={10,30,50};//
        List list= Arrays.asList(arr);
        System.out.println(list);
        //基本数据类型数组他会把整个数组当成一个整体
        //相当于List<int[]> list= Arrays.asList(arr);

        Integer[] arr2={10,30,50};
        List list2= Arrays.asList(arr2);
        System.out.println(list2);
        //引用数据类型，会把里面的每个元素进行转换
        //List<Integer> list2= Arrays.asList(arr2);
    }

    /**
     * list转数组
     */
    public static void trslate2(){
        ArrayList<java.lang.String> strings = new ArrayList<>();
        strings.add("gg1");
        strings.add("gg2fddsfs");
        strings.add("ggdsf3");
        //无参转换,返回Object类型
        Object[] objects = strings.toArray();
        System.out.println(Arrays.toString(objects));
        //有参转换，指定类型，约束空间
        String[] strings1 = strings.toArray(new String[10]);
        String[] strings2 = strings.toArray(new String[0]);
        //静态开辟内存空间，如果不够就开辟strings.size大小空间
        //如果超出部分就用null补全
        System.out.println(Arrays.toString(strings1));
        System.out.println(Arrays.toString(strings2));
    }

    /**
     * 集合嵌套
     */
    public static void nested(){
        Student s1=new Student("s1",18);
        Student s2=new Student("s2",18);
        Student s3=new Student("s3",18);
        Student s4=new Student("s4",18);
        ArrayList<Student> students1 = new ArrayList<>();
        ArrayList<Student> students2 = new ArrayList<>();
        students1.add(s1);
        students1.add(s2);
        students2.add(s3);
        students2.add(s4);
        ArrayList<List<Student>> lists = new ArrayList<>();
        lists.add(students1);
        lists.add(students2);
        //嵌套集合遍历
        for (List<Student> list : lists) {
            System.out.println(list+"的学生有：");
            for (Student student : list) {
                System.out.println(student.name);

            }

        }
    }
}



/**
 * 泛型类
 * 创建时指明类型，不指明就是object类型
 */
class Point <T>{
    T x;
    T y;

    public Point() {
    }

    /**
     * 泛型方法,参数有泛型
     * @param x x
     * @param y y
     */
    public Point(T x, T y) {
        this.x = x;
        this.y = y;
    }
    static <T> void test3(T name){

    }
}
